import java.util.Arrays;

public class Test {
    public static int[] mySort(int[] array) {
        int left = 0;
        int right = array.length - 1;
        while(left < right) {
            while(array[left] %2 != 0 && left < right) {
                left++;
            }
            while(array[right] %2 == 0 && left < right) {
                right--;
            }
            if(array[left] %2 == 0 && array[right] %2 != 0){
                int tmp = array[left];
                array[left] = array[right];
                array[right] = tmp;
            }
        }
        return array;
    }
    public static void main(String[] args) {
//        调整数组顺序使得奇数位于偶数之前。调整之后，不关心大小顺序。
//        如数组：[1,2,3,4,5,6]
//        调整后可能是：[1, 5, 3, 4, 2, 6]
        int[] array = {1,2,3,4,5,6};
        int[] ret = mySort(array);
        for (int i = 0; i < ret.length; i++) {
            System.out.println(ret[i]);
        }
    }
//    public static boolean mySort(int[] array) {
//        boolean n = false;
//        for (int i = 0; i < array.length; i++) {
//            int count = 0;
//            for (int j = i; j < array.length; j++) {
//                if(array[j] % 2 != 0) {
//                    count++;
//                }
//            }
//            if(count == 3) {
//                n = true;
//                break;
//            }
//        }
//        return n;
//    }
//
//    public static void main(String[] args) {
////        给你一个整数数组 arr，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 true ；否则，返回 false 。
////        示例 1：
////        输入：arr = [2,6,4,1]
////        输出：false
////        解释：不存在连续三个元素都是奇数的情况。
////        示例 2：
////        输入：arr = [1,2,34,3,4,5,7,23,12]
////        输出：true
////        解释：存在连续三个元素都是奇数的情况，即 [5,7,23] 。
//        int[] array = {1,2,34,3,4,5,7,23,12};
//        boolean ret = mySort(array);
//        System.out.println(ret);
//    }

//    public static int mySort(int[] array) {
//        int n = array.length / 2;
//        int y = 0;
//        for (int i = 0; i < array.length; i++) {
//            int count = 0;
//            for (int j = 1; j < array.length; j++) {
//                if(array[i] == array[j]) {
//                    count++;
//                }
//            }
//            if(count > n) {
//                y =  array[i];
//            }
//        }
//        return y;
//    }
//    public static void main(String[] args) {
////        给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
////        你可以假设数组是非空的，并且给定的数组总是存在多数元素。
////        示例 1：
////        输入：[3,2,3]
////        输出：3
////        示例 2：
////        输入：[2,2,1,1,1,2,2]
////        输出：2
//        int[] array = {2,2,1,1,1,1,1,1,1,1,2,2};
//        int ret = mySort(array);
//        System.out.println(ret);
//    }

//    public static int mySrot(int[] array) {
//        int f = 0;
//        for (int i = 0; i < array.length; i++) {
//            int n = 0;
//            for (int j = 0; j < array.length; j++) {
//                if(array[i] == array[j]) {
//                    n++;
//                }
//            }
//            if(n == 1) {
//                f = i;
//                break;
//            }
//        }
//        return f;
//    }
//
//    public static void main(String[] args) {
////        给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
////        示例 1:
////        输入: [2,2,1]
////        输出: 1
////        示例 2:
////        输入: [4,1,2,1,2]
////        输出: 4
//        int[] array = {2,2,1};
//        int ret = mySrot(array);
//        System.out.println(array[ret]);
//    }
//    public static int[] mySrot(int[] nums,int n) {
//        int[] array = new int[2];
//        for (int i = 0; i < nums.length; i++) {
//            for (int j = 1; j < nums.length; j++) {
//                if(nums[i] + nums[j] == n) {
//                    array[0] = i;
//                    array[1] = j;
//                    break;
//                }
//            }
//        }
//        return array;
//    }
//    public static void main(String[] args) {
////        给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
////        你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
////        你可以按任意顺序返回答案。
////        示例 1：
////        输入：nums = [2,7,11,15], target = 9
////        输出：[0,1]
////        解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
//        int[] nums = {2,7,11,15,29};
//        int target = 17;
//        int[] array= mySrot(nums,target);
//        for (int i = 0; i < array.length; i++) {
//            System.out.println(array[i]);
//        }
//    }

//    public static int[] mySort(int[] array) {
//
//        for (int i = 0; i < array.length - 1; i++) {
//            int n = 0;
//            for (int j = 0; j < array.length - 1 - i; j++) {
//                if(array[j] > array[j + 1]) {
//                    n = 1;
//                    int tmp = array[j];
//                    array[j] = array[j + 1];
//                    array[j+1] = tmp;
//                }
//            }
//            if(n == 0) {
//                break;
//            }
//        }
//        return array;
//    }
//
//    public static void main(String[] args) {
//        //给定一个整型数组, 实现冒泡排序(升序排序)
//        int[] array = {1,5,3,4,6,8,7,9};
//        mySort(array);
//        for (int i = 0; i < array.length; i++) {
//            System.out.println(array[i]);
//        }
//    }

//    public static int mySearch(int k,int[] array) {
//        int left = 0;
//        int right = array.length - 1;
//        while(left <= right) {
//            int map = (left + right) / 2;
//            if(k < array[map]) {
//                right = map - 1;
//            }else if(k > array[map]) {
//                left = map + 1;
//            }else if(array[map] == k){
//                return map;
//            }
//        }
//        return -1;
//    }
//
//    public static void main(String[] args) {
//        //给定一个有序整型数组, 实现二分查找
//        int[] array = {1,2,3,4,5,6,7,8,9,10};
//        int k = 4;
//        int ret = mySearch(k,array);
//        if(ret == -1) {
//            System.out.println("没找到");
//        }else {
//            System.out.println("找到了，下标是：" + ret);
//        }
//    }


    public static double myAvg(int[] array) {
        int count = 0;
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += array[i];
            count++;
        }
        return (double)sum / count;
    }
    public static void main7(String[] args) {
        //实现一个方法 avg, 以数组为参数, 求数组中所有元素的平均值(注意方法的返回值类型).
        int[] array = new int[100];
        for (int i = 1; i <= 100; i++) {
            array[i -1] = i;
        }
        double ret = myAvg(array);
        System.out.println(ret);
    }

    public static int mySum(int[] array) {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += array[i];
        }
        return sum;
    }

    public static void main5(String[] args) {
        //实现一个方法 sum, 以数组为参数, 求数组所有元素之和.
        int[] array = new int[100];
        for (int i = 1; i <= 100; i++) {
            array[i -1] = i;
        }
        int ret = mySum(array);
        System.out.println(ret);
    }



    public  static void myTransform(int[] array) {
        for (int i = 0; i < 100; i++) {
            array[i] = array[i] * 2;
        }
    }
    public static void main4(String[] args){
        //实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 , 并设置到对应的数组元素上.
        // 例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}
        int[] array = new int[100];
        for (int i = 1; i <= 100; i++) {
            array[i - 1] = i;
        };
        myTransform(array);
        printArray(array);
    }



        public static void printArray(int[] array) {
            for (int i = 0; i < 100; i++) {
                System.out.println(array[i]);
            }

        }
        public static void main2(String[] args){
            //实现一个方法 printArray, 以数组为参数, 循环访问数组中的每个元素, 打印每个元素的值.
            int[] array = new int[100];
            for (int i = 1; i <= 100; i++) {
                array[i - 1] = i;
            };
            printArray(array);
        }


    public static void main3(String[] args) {
        //创建一个 int 类型的数组, 元素个数为 100, 并把每个元素依次设置为 1 - 100
        int[] array = new int[100];
        for (int i = 1; i <= 100; i++) {
          array[i -1] = i;
        };
    }
}
